boolean.hpp
namespace type_safe
{
class boolean;
constexpr bool operator==(const boolean& a, const boolean& b) noexcept;
template <typename T>
constexpr bool operator==(const boolean& a, T b) noexcept;
template <typename T>
constexpr bool operator==(T a, const boolean& b) noexcept;
constexpr bool operator!=(const boolean& a, const boolean& b) noexcept;
template <typename T>
constexpr bool operator!=(const boolean& a, T b) noexcept;
template <typename T>
constexpr bool operator!=(T a, const boolean& b) noexcept;
//=== Input/output ===//
template <typename Char, class CharTraits>
std::basic_istream<Char, CharTraits>& operator>>(std::basic_istream<Char, CharTraits>& in, boolean& b);
template <typename Char, class CharTraits>
std::basic_ostream<Char, CharTraits>& operator<<(std::basic_ostream<Char, CharTraits>& out, const boolean& b);
//=== Comparison function objects ===//
struct equal_to;
struct not_equal_to;
struct less;
struct less_equal;
struct greater;
struct greater_equal;
}
namespace std
{
}
type_safe::boolean
[types]class boolean
{
public:
boolean() = delete;
template <typename T, typename = detail::enable_boolean<T>>
constexpr boolean(T value) noexcept;
template <typename T, typename = detail::enable_boolean<T>>
boolean& operator=(T value) noexcept;
constexpr operator bool() const noexcept;
constexpr boolean operator!() const noexcept;
};
A type safe boolean class.
It is a tiny, no overhead wrapper over bool
. It can only be constructed from bool
values and does not implicitly convert to integral types.
type_safe::boolean::boolean
template <typename T, typename = detail::enable_boolean<T>>
constexpr boolean(T value) noexcept;
Effects: Creates a boolean from the given value
.
Notes: This function does not participate in overload resolution if T
is not a boolean type. \param 1 \exclude
type_safe::boolean::operator=
template <typename T, typename = detail::enable_boolean<T>>
boolean& operator=(T value) noexcept;
Effects: Assigns the given value
to the boolean.
Notes: This function does not participate in overload resolution if T
is not a boolean type. \param 1 \exclude
type_safe::boolean::operator bool
constexpr operator bool() const noexcept;
Returns: The stored bool
value.
type_safe::boolean::operator!
constexpr boolean operator!() const noexcept;
Returns: The same as !static_cast<bool>(*this)
.
type_safe::operator==
[types](1) constexpr bool operator==(const boolean& a, const boolean& b) noexcept;
(2) template <typename T>
constexpr bool operator==(const boolean& a, T b) noexcept;
(3) template <typename T>
constexpr bool operator==(T a, const boolean& b) noexcept;
ts::boolean equality comparison.
Returns: true
if (1) both ts::boolean objects have the same value, (2)/(3) the boolean has the same value as the given value, false
otherwise.
Notes: (2)/(3) do not participate in overload resolution if T
is not a boolean type.
type_safe::operator!=
[types](1) constexpr bool operator!=(const boolean& a, const boolean& b) noexcept;
(2) template <typename T>
constexpr bool operator!=(const boolean& a, T b) noexcept;
(3) template <typename T>
constexpr bool operator!=(T a, const boolean& b) noexcept;
ts::boolean in-equality comparison.
Returns: false
if (1) both ts::boolean objects have the same value, (2)/(3) the boolean has the same value as the given value, true
otherwise.
Notes: (2)/(3) do not participate in overload resolution if T
is not a boolean type.
type_safe::operator>>
[types]template <typename Char, class CharTraits>
std::basic_istream<Char, CharTraits>& operator>>(std::basic_istream<Char, CharTraits>& in, boolean& b);
ts::boolean input operator.
Effects: Reads a bool
from the std::istream and assigns it to the given ts::boolean.
type_safe::operator<<
[types]template <typename Char, class CharTraits>
std::basic_ostream<Char, CharTraits>& operator<<(std::basic_ostream<Char, CharTraits>& out, const boolean& b);
ts::boolean output operator.
Effects: Converts the given ts::boolean to bool
and writes it to the std::ostream.
(1) struct equal_to
{
using is_transparent = int;
template <typename T1, typename T2>
constexpr bool operator()(T1&& a, T2&& b) const noexcept('hidden');
};
(2) struct not_equal_to
{
using is_transparent = int;
template <typename T1, typename T2>
constexpr bool operator()(T1&& a, T2&& b) const noexcept('hidden');
};
(3) struct less
{
using is_transparent = int;
template <typename T1, typename T2>
constexpr bool operator()(T1&& a, T2&& b) const noexcept('hidden');
};
(4) struct less_equal
{
using is_transparent = int;
template <typename T1, typename T2>
constexpr bool operator()(T1&& a, T2&& b) const noexcept('hidden');
};
(5) struct greater
{
using is_transparent = int;
template <typename T1, typename T2>
constexpr bool operator()(T1&& a, T2&& b) const noexcept('hidden');
};
(6) struct greater_equal
{
using is_transparent = int;
template <typename T1, typename T2>
constexpr bool operator()(T1&& a, T2&& b) const noexcept('hidden');
};
Comparison functors similar to the std::
version, but explicitly cast the result of the comparison to bool
.
This allows using types where the comparison operator returns ts::boolean, as it can not be implicitly converted to bool
so, for example, std::less can not be used.
Notes: These comparison functors are always transparent, i.e. can be used with two different types.